package cycling.taxi.com.ui.activity;

import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.media.Image;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.provider.SyncStateContract;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.LruCache;
import android.widget.ImageView;

import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.ImageRequest;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import butterknife.ButterKnife;
import butterknife.InjectView;
import cycling.taxi.com.R;
import cycling.taxi.com.entity.CommonQuestion;
import cycling.taxi.com.utils.LogUtil;
import cycling.taxi.com.utils.SPUtil;
import cycling.taxi.com.utils.ToastUtil;
import cycling.taxi.com.utils.Urls;

public class Testnew extends AppCompatActivity {
    private RequestQueue queue;
    private ImageLoader imgl;
    @InjectView(R.id.testImg)
    ImageView testImg;
    String dir = Environment.getExternalStorageDirectory().getAbsolutePath() + "/cycling.taxi.com";
    private List<Bitmap> bitmaps=null;
    //Bitmap mBitmap;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_testnew);
        queue=Volley.newRequestQueue(this);
        ButterKnife.inject(this);
     //   ToastUtil.getInstance().toast(dir);
     //   volleyGet2();
      //  getAllimg(dir);
        bitmaps=getPictures(dir);
        testImg.setImageBitmap(bitmaps.get(0));
//        for(int i=0;i<bitmaps.size();i++){
//            LogUtil.e(bitmaps.get(i));
//        }

    }
    public void volleyGet(){
        // String path="http://192.168.1.100:8080/CyclingBgTV1/appRepairByself/repairByself.dop";
        String path = "http://47.92.134.208:8081/images/AppImages/20170731104610170.png";
        ImageRequest request = new ImageRequest(path,new Response.Listener<Bitmap>() {
            @Override
            public void onResponse(Bitmap response) {
                testImg.setImageBitmap(response);
            }
        }, 0, 0, Bitmap.Config.RGB_565, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                testImg.setImageResource(R.drawable.splash_bg);
            }
        });

        queue.add(request);
    }
    public void volleyGet2(){
        String path=Urls.getImg()+"AppImages/20170731104610170.png";
        ImageLoader imageLoader = new ImageLoader(queue, new BitmapCache());
//        ImageLoader.ImageListener listener = ImageLoader.getImageListener(testImg,
//                R.drawable.splash_bg, R.drawable.splash_bg);
//        imageLoader.get(path, listener);
        imageLoader.get(path, new ImageLoader.ImageListener() {
            @Override
            public void onResponse(ImageLoader.ImageContainer imageContainer, boolean b) {
               // testImg.setImageBitmap(imageContainer.getBitmap());
                ToastUtil.getInstance().toast(dir);
            }

            @Override
            public void onErrorResponse(VolleyError volleyError) {

            }
        });

    }
    public class BitmapCache implements ImageLoader.ImageCache {

        private LruCache<String, Bitmap> mCache;

        public BitmapCache() {
            int maxSize = 10 * 1024 * 1024;
            mCache = new LruCache<String, Bitmap>(maxSize) {
                @Override
                protected int sizeOf(String key, Bitmap bitmap) {
                    return bitmap.getRowBytes() * bitmap.getHeight();
                }
            };
        }

        /**
         * 先从缓存中找，有则返回图片，没有则从网络获取
         */
        @Override
        public Bitmap getBitmap(String url) {
            /**
             * 先从缓存中找，有则返回，没有则返回null
             */
            Bitmap bitmap = mCache.get(url);

            if (bitmap == null) {
                String fileName = url.substring(url.lastIndexOf("/") + 1);
                /**
                 * 如果为null，则缓存中没有，从本地SD卡缓存中找
                 */
                File cacheDir = new File(dir);
                File[] cacheFiles = cacheDir.listFiles();
                if (cacheFiles != null) {
                    int i = 0;
                    for (; i < cacheFiles.length; i++) {
                        if (TextUtils.equals(fileName, cacheFiles[i].getName()))
                            break;
                    }
                    /**
                     * 若找到则返回bitmap否则返回null
                     */
                    if (i < cacheFiles.length) {
                        bitmap = getSDBitmap(dir + "/"
                                + fileName);
                        /**
                         * 将从SD卡中获取的bitmap放入缓存中
                         */
                        mCache.put(url, bitmap);
                    }
                }
            }
            return bitmap;
        }

        @Override
        public void putBitmap(String url, Bitmap bitmap) {
            /**
             * 放入缓存中
             */
            mCache.put(url, bitmap);
            /**
             * 存到本地SD中
             */
            putSDBitmap(url.substring(url.lastIndexOf("/") + 1), bitmap);
        }

        /**
         * 从本地SD卡中获取图片
         *
         * @param imgPath
         *            图片路径
         * @return 图片的Bitmap
         */
        private Bitmap getSDBitmap(String imgPath) {
            Bitmap bm = null;
            BitmapFactory.Options options = new BitmapFactory.Options();
            /**
             * 设置临时缓存大小
             */
            options.inTempStorage = new byte[1024 * 1024];
            /**
             * 通过设置Options.inPreferredConfig值来降低内存消耗： 默认为ARGB_8888: 每个像素4字节. 共32位。
             * Alpha_8: 只保存透明度，共8位，1字节。 ARGB_4444: 共16位，2字节。 RGB_565:共16位，2字节
             */
            options.inPreferredConfig = Bitmap.Config.ARGB_8888;
            /**
             * inPurgeable:设置为True,则使用BitmapFactory创建的Bitmap用于存储Pixel的内存空间，
             * 在系统内存不足时可以被回收，当应用需要再次访问该Bitmap的Pixel时，系统会再次调用BitmapFactory
             * 的decode方法重新生成Bitmap的Pixel数组。 设置为False时，表示不能被回收。
             */
            options.inPurgeable = true;
            options.inInputShareable = true;
            /**
             * 设置decode时的缩放比例。
             */
            options.inSampleSize = 1;
            bm = BitmapFactory.decodeFile(imgPath, options);
            return bm;
        }

        /**
         * 将图片保存到本地的SD卡中
         *
         * @param fileName
         * @param bitmap
         */
        private void putSDBitmap(final String fileName, final Bitmap bitmap) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    File cacheDir = new File(dir);
                    if (!cacheDir.exists())
                        cacheDir.mkdirs();
                    File cacheFile = new File(dir + "/"
                            + fileName);
                    if (!cacheFile.exists()) {
                        try {
                            cacheFile.createNewFile();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    FileOutputStream fos;
                    try {
                        fos = new FileOutputStream(cacheFile);
                        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
                        fos.close();
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

    }
    public List<Bitmap> getPictures(final String strPath) {
        List<String> list = new ArrayList<String>();
        List<Bitmap> bitmapList=new ArrayList<Bitmap>();
        File file = new File(strPath);
        File[] allfiles = file.listFiles();
        if (allfiles == null) {
            return null;
        }
        for(int k = 0; k < allfiles.length; k++) {
            final File fi = allfiles[k];
            if(fi.isFile()) {
                int idx = fi.getPath().lastIndexOf(".");
                if (idx <= 0) {
                    continue;
                }
                String suffix = fi.getPath().substring(idx);
                if (suffix.toLowerCase().equals(".jpg") ||
                        suffix.toLowerCase().equals(".jpeg") ||
                        suffix.toLowerCase().equals(".bmp") ||
                        suffix.toLowerCase().equals(".png") ||
                        suffix.toLowerCase().equals(".gif") ) {
                    list.add(fi.getPath());
                    Bitmap bm = BitmapFactory.decodeFile(fi.getPath());
                    bitmapList.add(bm);
                }
            }
        }
        return bitmapList;
    }
//    Bitmap bm = BitmapFactory.decodeFile(filepath);
//    //将图片显示到ImageView中
//                        img.setImageBitmap(bm);
}
